/*
* @Author: zhangpeng
* @Description: 工具类
* @LastEditTime: 2024-03-08 15:05:04
*/

import regex from '@/tools/regex'
import { sm2, sm3 } from 'sm-crypto'
import JSSM4 from "jssm4"
import CryptoJS from "crypto-js"

/**
 * 加解密
 */
export default {
    // sm2加密
    encryptSM2 (text, key) {
        key =
            key ||
            "04f776b67b25293281842ffe76ceef897f0222a8153d469e4a279b9f0afece6d5ca535f45cb40c196af3eeb41dad8c741df46a369d4bb9c655c0fec9fef3f54ba8"
        const enText = sm2.doEncrypt(text, key, 1)
        return "04" + enText
    },
    // sm2解密
    decryptSM2 (text, key) {
        key =
            key || "00bf7b2a2c114efbb51f58ed8cb8e11080c1d7fae1531d10dab1c3857b7a5d0be2"
        const deText = sm2.doDecrypt(text.slice(2), key, 1)
        return deText
    },
    // sm3加密
    encryptSM3 (text) {
        return sm3.sm3_hash(text)
    },
    // sm3解密
    decryptSM3 (text) {
        return sm3.sm3_hash(text)
    },
    // sm4加密
    encryptSM4 (text, key) {
        key = key || "11fa0b98b4974c0d"
        let sm4 = new JSSM4(key)
        return sm4.encryptData_ECB(text)
    },
    // sm4解密
    decryptSM4 (text, key) {
        key = key || "11fa0b98b4974c0d"
        let sm4 = new JSSM4(key)
        return sm4.decryptData_ECB(text)
    },
    //AES加密
    encryptAES (word, keyStr) {
        keyStr = keyStr ? keyStr : "ad555e777edc4c34a99d546926221d1f" //判断是否存在ksy，不存在就用定义好的key
        let key = CryptoJS.enc.Utf8.parse(keyStr)
        let srcs = CryptoJS.enc.Utf8.parse(word)
        let encrypted = CryptoJS.AES.encrypt(srcs, key, {
            mode: CryptoJS.mode.ECB,
            padding: CryptoJS.pad.Pkcs7
        })
        return encrypted.toString()
    },
    //AES解密
    decryptAES (word, keyStr) {
        keyStr = keyStr ? keyStr : "ad555e777edc4c34a99d546926221d1f"
        let key = CryptoJS.enc.Utf8.parse(keyStr)
        let decrypt = CryptoJS.AES.decrypt(word, key, {
            mode: CryptoJS.mode.ECB,
            padding: CryptoJS.pad.Pkcs7
        })
        return CryptoJS.enc.Utf8.stringify(decrypt).toString()
    },
}

/**
 * 脱敏处理相关方法
 * ——————————————————————————————————————————————————————————————————————————————————————————————————————
 */

/**
 * 对姓名进行脱敏处理
 * @param {string} name 要脱敏的姓名
 * @returns {string} 脱敏后的姓名
 */
export function desensitizationName (name) {
    if (!name) return '';
    const length = name.length;
    if (length === 2) {
        // 两个字，隐藏第一个字
        return '*' + name[1];
    } else if (length === 3) {
        // 三个字，隐藏第一个字
        return '*' + name.slice(1);
    } else if (length > 3 && length <= 6) {
        // 六个字以下（含），三个字以上，只显示最后两个字
        return '*'.repeat(length - 2) + name.slice(-2);
    } else if (length > 6) {
        // 六个字以上的，显示前第一个字和最后两个字
        return name[0] + '*'.repeat(length - 3) + name.slice(-2);
    }
    return name;
}

/**
 * 对银行卡号进行脱敏处理
 * @param {string} str 要脱敏的银行卡号
 * @returns {string} 脱敏后的银行卡号
 */
export function desensitizationBank (str) {
    if (str.length <= 8) {
        // 如果字符串长度小于等于8，直接返回原字符串
        return str;
    }
    // 获取前四位和后四位
    const firstFour = str.slice(0, 4);
    const lastFour = str.slice(-4);
    // 中间部分用星号替换
    const middle = '*'.repeat(str.length - 8);
    // 返回脱敏后的字符串
    return firstFour + middle + lastFour;
}

/**
 * 对卡号进行脱敏处理
 * @param {string} str 要脱敏的卡号
 * @returns {string} 脱敏后的卡号
 */
export function desensitizationCardNum (str) {
    const length = str.length;
    if (length <= 3) {
        // 如果字符串长度小于等于3，直接返回原字符串
        return str;
    }
    // 计算前1/3和后1/3的长度
    const frontLength = Math.ceil(length / 3); // 前部分长度
    const rearLength = Math.floor(length / 3); // 后部分长度
    // 获取前1/3和后1/3的内容
    const front = str.slice(0, frontLength);
    const rear = str.slice(-rearLength);
    // 中间部分用*号替换
    const middle = '*'.repeat(length - frontLength - rearLength);
    // 返回脱敏后的字符串
    return front + middle + rear;
}

/**
 * 对身份证号进行脱敏处理
 * @param {string} id 要脱敏的身份证号
 * @returns {string} 脱敏后的身份证号
 */
export function desensitizationId (id) {
    if (!id || id.length < 2) return id; // 如果证件号为空或长度不足，直接返回
    // 显示第一位 + '*'（实际位数） + 最后一位
    const firstChar = id[0]; // 第一位
    const lastChar = id[id.length - 1]; // 最后一位
    const maskedPart = '*'.repeat(id.length - 2); // 中间部分用 '*' 代替
    return firstChar + maskedPart + lastChar;
}

/**
 * 对大陆手机号进行脱敏处理
 * @param {string} phone 要脱敏的手机号
 * @returns {string} 脱敏后的手机号
 */
export function desensitizationPhone (phone) {
    if (!phone || phone.length < 5) return phone;
    const firstThree = phone.slice(0, 3);
    const lastTwo = phone.slice(-2);
    const middleStars = '*'.repeat(phone.length - 5);
    return firstThree + middleStars + lastTwo;
}

/**
 * 对香港、澳门手机号进行脱敏处理
 * @param {string} phone 要脱敏的手机号
 * @returns {string} 脱敏后的手机号
 */
export function desensitizationPhoneXG (phone) {
    if (!phone || phone.length < 5) return phone;
    const firstThree = phone.slice(0, 2);
    const lastTwo = phone.slice(-2);
    const middleStars = '*'.repeat(phone.length - 4);
    return firstThree + middleStars + lastTwo;
}

/**
 * 对台湾手机号进行脱敏处理
 * @param {string} phone 要脱敏的手机号
 * @returns {string} 脱敏后的手机号
 */
export function desensitizationPhoneTW (phone) {
    if (!phone || phone.length < 5) return phone;
    const firstThree = phone.slice(0, 2);
    const lastTwo = phone.slice(-3);
    const middleStars = '*'.repeat(phone.length - 5);
    return firstThree + middleStars + lastTwo;
}

/**
 * 对固定电话进行脱敏处理
 * @param {string} phone 要脱敏的固定电话
 * @returns {string} 脱敏后的固定电话
 */
export function desensitizationTel (phone) {
    if (!phone) return phone;
    const hasAreaCode = /^(\d{3,4}-|\d{3,4}\()/.test(phone);
    let areaCode = '';
    let mainNumber = phone;
    if (hasAreaCode) {
        const areaCodeMatch = phone.match(/^(\d{3,4})[-()]/);
        if (areaCodeMatch) {
            areaCode = areaCodeMatch[1] + '*';
            mainNumber = phone.slice(areaCode.length);
        }
    }
    const lastFour = mainNumber.slice(-4);
    const maskedPart = '*'.repeat(mainNumber.length - 4);
    return areaCode + maskedPart + lastFour;
}

/**
 * 对邮箱进行脱敏处理
 * @param {string} email 要脱敏的邮箱
 * @returns {string} 脱敏后的邮箱
 */
export function desensitizationEmail (email) {
    if (!email) return email;
    const atIndex = email.indexOf('@');
    if (atIndex === -1) return email;
    const prefix = email.slice(0, atIndex);
    const suffix = email.slice(atIndex);
    const visiblePrefix = prefix.slice(0, 3);
    const maskedPrefix = visiblePrefix + '***';
    return maskedPrefix + suffix;
}

/**
 * 对地址进行脱敏处理
 * @param {string} address 要脱敏的地址
 * @returns {string} 脱敏后的地址
 */
export function desensitizationAddress (address) {
    const regex = /^(.*?(省|自治区|市))?(.*?(市|自治州|地区))?(.*?(区|县|市))/;
    const match = address.match(regex);
    if (match) {
        const province = match[1] || '';
        const city = match[3] || '';
        const district = match[5] || '';
        return `${province.trim()} ${city.trim()} ${district.trim()} ******`;
    } else {
        // 如果未匹配到省市区，直接脱敏后四位
        const length = address.length;
        if (length <= 4) {
            return '****'; // 如果地址长度小于等于4，直接返回
        }
        return address.substring(0, length - 4) + '****';
    }
}

/**
 * 对QQ号进行脱敏处理
 * @param {string} str 要脱敏的QQ号
 * @returns {string} 脱敏后的QQ号
 */
export function desensitizationQQ (str) {
    if (str.length <= 2) {
        return str;
    }
    const firstChar = str[0];
    const lastChar = str[str.length - 1];
    const maskedPart = '*'.repeat(str.length - 2);
    return firstChar + maskedPart + lastChar;
}

/**
 * 对日期进行脱敏处理
 * @param {string} str 要脱敏的日期
 * @returns {string} 脱敏后的日期
 */
export function desensitizationDate (str) {
    const maskedPart = '*'.repeat(str.length);
    return maskedPart;
}





/**
 * 校验相关方法
 * ——————————————————————————————————————————————————————————————————————————————————————————————————————
 */

/**
 * 对中文姓名进行校验
 * @param {string} str 要校验的姓名
 * @param {number} [num=25] 姓名最大字符数，默认为25
 * @returns {{result: boolean, msg: string}}
 */
export function validateName (str, num = 25) {
    if (!str) {
        return { result: false, msg: '请输入中文姓名' };
    } else if (str.length > num) {
        return { result: false, msg: `中文姓名最多${num}个字` };
    } else if (!regex.validateName.test(str)) {
        return { result: false, msg: '请输入正确的中文姓名' };
    }
    return { result: true, msg: '' };
}

/**
 * 对用户名进行校验
 * @param {string} str 要校验的用户名
 * @param {number} [num=25] 用户名最大字符数，默认为25
 * @returns {{result: boolean, msg: string}}
 */
export function validateUsername (str, num = 25) {
    if (!str) {
        return { result: false, msg: '请输入用户名' };
    } else if (str.length > num) {
        return { result: false, msg: `用户名最多${num}个字` };
    } else if (!regex.validateUsername.test(str)) {
        return { result: false, msg: '请输入正确的用户名' };
    }
    return { result: true, msg: '' };
}

/**
 * 对昵称进行校验
 * @param {string} str 要校验的昵称
 * @param {number} [num=25] 昵称最大字符数，默认为25
 * @returns {{result: boolean, msg: string}}
 */
export function validateNickname (str, num = 25) {
    if (!str) {
        return { result: false, msg: '请输入昵称' };
    } else if (str.length > num) {
        return { result: false, msg: `昵称最多${num}个字` };
    } else if (!regex.validateNickname.test(str)) {
        return { result: false, msg: '请输入正确的昵称' };
    }
    return { result: true, msg: '' };
}

/**
 * 对身份证号进行校验
 * @param {string} str 要校验的身份证号
 * @returns {{result: boolean, msg: string}}
 */
export function validateIdcard (str) {
    if (!str) {
        return { result: false, msg: '请输入身份证号' };
    } else if (str.length != 18) {
        return { result: false, msg: `身份证号固定为18位` };
    } else if (!regex.validateIdcard.test(str)) {
        return { result: false, msg: '请输入正确的身份证号' };
    }
    return { result: true, msg: '' };
}

/**
 * 对军官证号进行校验
 * @param {string} str 要校验的军官证号
 * @returns {{result: boolean, msg: string}}
 */
export function validateOfficer (str) {
    if (!str) {
        return { result: false, msg: '请输入军官证号' };
    } else if (str.length != 8) {
        return { result: false, msg: `军官证号固定为8位` };
    } else if (!regex.validateOfficer.test(str)) {
        return { result: false, msg: '请输入正确的军官证号' };
    }
    return { result: true, msg: '' };
}

/**
 * 对护照号进行校验
 * @param {string} str 要校验的护照号
 * @returns {{result: boolean, msg: string}}
 */
export function validatePassport (str) {
    if (!str) {
        return { result: false, msg: '请输入护照号' };
    } else if (str.length != 9) {
        return { result: false, msg: `护照号固定为9位` };
    } else if (!regex.validatePassport.test(str)) {
        return { result: false, msg: '请输入正确的护照号' };
    }
    return { result: true, msg: '' };
}

/**
 * 对电子邮箱进行校验
 * @param {string} str 要校验的电子邮箱
 * @param {number} [num=50] 电子邮箱最大长度，默认为50
 * @returns {{result: boolean, msg: string}}
 */
export function validateEmail (str, num = 50) {
    if (!str) {
        return { result: false, msg: '请输入电子邮箱' };
    } else if (str.length > num) {
        return { result: false, msg: `电子邮箱最多${num}位` };
    } else if (!regex.validateEmail.test(str)) {
        return { result: false, msg: '请输入正确的电子邮箱' };
    }
    return { result: true, msg: '' };
}

/**
 * 对手机号进行校验
 * @param {string} str 要校验的手机号
 * @returns {{result: boolean, msg: string}}
 */
export function validatePhone (str) {
    if (!str) {
        return { result: false, msg: '请输入手机号' };
    } else if (str.length != 11) {
        return { result: false, msg: `手机号固定为11位` };
    } else if (!regex.validatePhone.test(str)) {
        return { result: false, msg: '请输入正确的手机号' };
    }
    return { result: true, msg: '' };
}

/**
 * 对统一社会信用代码进行校验
 * @param {string} str 要校验的统一社会信用代码
 * @returns {{result: boolean, msg: string}}
 */
export function validateSocialCode (str) {
    if (!str) {
        return { result: false, msg: '请输入统一社会信用代码' };
    } else if (str.length != 18) {
        return { result: false, msg: `统一社会信用代码固定为18位` };
    } else if (!regex.validateSocialCode.test(str)) {
        return { result: false, msg: '请输入正确的统一社会信用代码' };
    }
    return { result: true, msg: '' };
}

/**
 * 对港澳居民来往内地通行证号进行校验
 * @param {string} str 要校验的通行证号
 * @returns {{result: boolean, msg: string}}
 */
export function validateHkTravel (str) {
    if (!str) {
        return { result: false, msg: '请输入港澳居民来往内地通行证号' };
    } else if (str.length != 9) {
        return { result: false, msg: `港澳居民来往内地通行证号固定为9位` };
    } else if (!regex.validateHkTravel.test(str)) {
        return { result: false, msg: '请输入正确的港澳居民来往内地通行证号' };
    }
    return { result: true, msg: '' };
}

/**
 * 对台湾居民来往大陆通行证号进行校验
 * @param {string} str 要校验的通行证号
 * @returns {{result: boolean, msg: string}}
 */
export function validateTWTravel (str) {
    if (!str) {
        return { result: false, msg: '请输入台湾居民来往大陆通行证号' };
    } else if (str.length != 8) {
        return { result: false, msg: `台湾居民来往大陆通行证号固定为8位` };
    } else if (!regex.validateTWTravel.test(str)) {
        return { result: false, msg: '请输入正确的台湾居民来往大陆通行证号' };
    }
    return { result: true, msg: '' };
}

/**
 * 对固定电话进行校验
 * @param {string} str 要校验的固定电话
 * @returns {{result: boolean, msg: string}}
 */
export function validateTel (str) {
    if (!str) {
        return { result: false, msg: '请输入固定电话' };
    } else if (str.length < 11 || str.length > 13) {
        return { result: false, msg: `固定电话为11~13位` };
    } else if (!regex.validateTel.test(str)) {
        return { result: false, msg: '请输入正确的固定电话' };
    }
    return { result: true, msg: '' };
}
/**
 * 对外国人永久居留身份证号进行校验
 * @param {string} str 要校验的外国人永久居留身份证号
 * @returns {{result: boolean, msg: string}}
 */
export function validateForeignerIdcard (str) {
    if (!str) {
        return { result: false, msg: '请输入外国人永久居留身份证号' };
    } else if (str.length != 15 && str.length != 18) {
        return { result: false, msg: `外国人永久居留身份证号固定为15或18位` };
    } else if (!regex.validateForeignerIdcard.test(str)) {
        return { result: false, msg: '请输入正确的外国人永久居留身份证号' };
    }
    return { result: true, msg: '' };
}

/**
 * 对准考证号进行校验
 * @param {string} str 要校验的准考证号
 * @param {number} [num=20] 准考证号最大长度，默认为20
 * @returns {{result: boolean, msg: string}}
 */
export function validateAdmissionCard (str, num = 20) {
    if (!str) {
        return { result: false, msg: '请输入准考证号' };
    } else if (str.length > num) {
        return { result: false, msg: `准考证号最多${num}位` };
    } else if (!regex.validateAdmissionCard.test(str)) {
        return { result: false, msg: '请输入正确的准考证号' };
    }
    return { result: true, msg: '' };
}

/**
 * 对银行卡号进行校验
 * @param {string} str 要校验的银行卡号
 * @returns {{result: boolean, msg: string}}
 */
export function validateBankCard (str) {
    if (!str) {
        return { result: false, msg: '请输入银行卡号' };
    } else if (str.length < 16 || str.length > 19) {
        return { result: false, msg: `银行卡号为16~19位` };
    } else if (!regex.validateBankCard.test(str)) {
        return { result: false, msg: '请输入正确的银行卡号' };
    }
    return { result: true, msg: '' };
}

/**
 * 对车牌号进行校验
 * @param {string} str 要校验的车牌号
 * @param {number} [num=8] 车牌号最大长度，默认为8
 * @returns {{result: boolean, msg: string}}
 */
export function validateCarNumber (str, num = 8) {
    if (!str) {
        return { result: false, msg: '请输入车牌号' };
    } else if (str.length > num) {
        return { result: false, msg: `车牌号最多${num}位` };
    } else if (!regex.validateCarNumber.test(str)) {
        return { result: false, msg: '请输入正确的车牌号' };
    }
    return { result: true, msg: '' };
}

/**
 * 对短信验证码进行校验
 * @param {string} str 要校验的短信验证码
 * @param {number} [num=6] 验证码长度，默认为6
 * @returns {{result: boolean, msg: string}}
 */
export function validateSmsCode (str, num = 6) {
    if (!str) {
        return { result: false, msg: '请输入短信验证码' };
    } else if (str.length > num) {
        return { result: false, msg: `短信验证码最多${num}位` };
    } else if (!regex.validateSmsCode.test(str)) {
        return { result: false, msg: '请输入正确的短信验证码' };
    }
    return { result: true, msg: '' };
}

/**
 * 对家庭住址/联系地址进行校验
 * @param {string} str 要校验的地址
 * @param {number} [num=50] 地址最大长度，默认为50
 * @returns {{result: boolean, msg: string}}
 */
export function validateAdress (str, num = 50) {
    if (!str) {
        return { result: false, msg: '请输入家庭住址/联系地址' };
    } else if (str.length > num) {
        return { result: false, msg: `家庭住址/联系地址最多${num}个字` };
    } else if (!regex.validateAdress.test(str)) {
        return { result: false, msg: '请输入正确的家庭住址/联系地址' };
    }
    return { result: true, msg: '' };
}

/**
 * 对评论评价、意见反馈、留言内容等多行输入进行校验
 * @param {string} str 要校验的内容
 * @param {number} [num=250] 内容最大长度，默认为250
 * @returns {{result: boolean, msg: string}}
 */
export function validateTextArea (str, num = 250) {
    if (!str) {
        return { result: false, msg: '请输入内容' };
    } else if (str.length > num) {
        return { result: false, msg: `内容最多${num}个字` };
    }
    return { result: true, msg: '' };
}

/**
 * 对年龄进行校验
 * @param {string} str 要校验的年龄
 * @param {number} [num=3] 年龄最大长度，默认为3
 * @returns {{result: boolean, msg: string}}
 */
export function validateAge (str, num = 3) {
    if (!str) {
        return { result: false, msg: '请输入年龄' };
    } else if (str.length > num) {
        return { result: false, msg: `年龄最多${num}位` };
    } else if (!regex.validateAge.test(str)) {
        return { result: false, msg: '请输入正确的年龄' };
    }
    return { result: true, msg: '' };
}

/**
 * 对日期进行校验
 * @param {string} str 要校验的日期
 * @param {number} [num=10] 日期最大长度，默认为10
 * @returns {{result: boolean, msg: string}}
 */
export function validateTime (str, num = 10) {
    if (!str) {
        return { result: false, msg: '请输入日期' };
    } else if (str.length > num) {
        return { result: false, msg: `日期最多${num}个字` };
    } else if (!regex.validateTime.test(str)) {
        return { result: false, msg: '请输入正确的日期' };
    }
    return { result: true, msg: '' };
}

/**
 * 对长度、面积、体积、时长、温度、速度、功率、存储等计量单位进行校验
 * @param {string} str 要校验的计量单位
 * @param {number} [num=20] 计量单位最大长度，默认为20
 * @returns {{result: boolean, msg: string}}
 */
export function validateCount (str, num = 20) {
    if (!str) {
        return { result: false, msg: '请输入计量单位' };
    } else if (str.length > num) {
        return { result: false, msg: `计量单位最多${num}位` };
    } else if (!regex.validateCount.test(str)) {
        return { result: false, msg: '请输入正确的计量单位' };
    }
    return { result: true, msg: '' };
}

/**
 * 对微信号进行校验
 * @param {string} str 要校验的微信号
 * @returns {{result: boolean, msg: string}}
 */
export function validateWechat (str) {
    if (!str) {
        return { result: false, msg: '请输入微信号' };
    } else if (str.length < 6 || str.length > 20) {
        return { result: false, msg: `微信号为6~20位` };
    } else if (!regex.validateWechat.test(str)) {
        return { result: false, msg: '请输入正确的微信号' };
    }
    return { result: true, msg: '' };
}

/**
 * 对QQ号进行校验
 * @param {string} str 要校验的QQ号
 * @returns {{result: boolean, msg: string}}
 */
export function validateQQ (str) {
    if (!str) {
        return { result: false, msg: '请输入QQ号' };
    } else if (str.length < 5 || str.length > 10) {
        return { result: false, msg: `QQ号为5~10位` };
    } else if (!regex.validateQQ.test(str)) {
        return { result: false, msg: '请输入正确的QQ号' };
    }
    return { result: true, msg: '' };
}

/**
 * 对书籍名进行校验
 * @param {string} str 要校验的书籍名
 * @param {number} [num=25] 书籍名最大长度，默认为25
 * @returns {{result: boolean, msg: string}}
 */
export function validateBook (str, num = 25) {
    if (!str) {
        return { result: false, msg: '请输入书籍名' };
    } else if (str.length > num) {
        return { result: false, msg: `书籍名最多${num}个字` };
    } else if (!regex.validateBook.test(str)) {
        return { result: false, msg: '请输入正确的书籍名' };
    }
    return { result: true, msg: '' };
}

/**
 * 对名称进行校验
 * @param {string} str 要校验的名称
 * @param {number} [num=25] 名称最大长度，默认为25
 * @returns {{result: boolean, msg: string}}
 */
export function validateItemName (str, num = 25) {
    if (!str) {
        return { result: false, msg: '请输入名称' };
    } else if (str.length > num) {
        return { result: false, msg: `名称最多${num}个字` };
    } else if (!regex.validateItemName.test(str)) {
        return { result: false, msg: '请输入正确的名称' };
    }
    return { result: true, msg: '' };
}




/**
 * 其他工具类
 * ————————————————————————————————————————————————————————————————————————————————————————————————————————————
 */

/**
 * 将时间戳转换为 "yyyy-mm-dd" 格式的日期字符串
 * @param timestamp 
 * @param type
 * @returns {string}
 */
export function changDateFormate (timestamp, type) {
    if (!timestamp) return "无"
    // 创建日期对象
    const date = new Date(timestamp);
    // 获取年、月、日，并确保其为两位数格式
    const year = date.getFullYear();
    const month = String(date.getMonth() + 1).padStart(2, "0");
    const day = String(date.getDate()).padStart(2, "0");
    const hours = String(date.getHours()).padStart(2, "0");
    const minutes = String(date.getMinutes()).padStart(2, "0");
    const seconds = String(date.getSeconds()).padStart(2, "0");
    // 拼接日期字符串
    if (type === 'yyyy-mm-dd') {
        const formattedDate = `${year}-${month}-${day}`;
        return formattedDate
    } else {
        const formattedDate = `${year}-${month}-${day} ${hours}:${minutes}:${seconds}`;
        return formattedDate
    }
}

/**
 * 解析URL中的查询参数，返回一个键值对的对象
 * @param data URL字符串
 * @returns 解析后的对象
 */
export function getRequest (data) {
    let url = data;
    let theRequest = new Object();
    if (url.indexOf("?") != -1) {
        let str = url.substr(1);
        let n = str.indexOf("?");
        let str2 = str.substr(n + 1)
        let strs = str2.split("&");
        for (let i = 0; i < strs.length; i++) {
            theRequest[strs[i].split("=")[0]] = (strs[i].split("=")[1]);
        }
    }
    return theRequest;
}

/**
 * 生成时间问候语
 * @returns {string} 根据当前时间返回问候语
 */
export function desensitizationTime () {
    const now = new Date();
    const hour = now.getHours();
    if (hour >= 5 && hour < 12) {
        return "早上好！";
    } else if (hour >= 12 && hour < 14) {
        return "中午好！";
    } else if (hour >= 14 && hour < 18) {
        return "下午好！";
    } else {
        return "晚上好！";
    }
}

